ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ ಮೆಮೊರಿ ದಕ್ಷತೆ: ಅಸಿಂಕ್ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಅಸಿಂಕ್ರೊನಸ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಏಕಕಾಲದಲ್ಲಿ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿಭಾಯಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಬ್ಲಾಕಿಂಗ್ ಅನ್ನು ತಡೆಯುತ್ತದೆ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್‌ನ ಸ್ಪಂದನಶೀಲತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ. ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳು ಮತ್ತು ಜನರೇಟರ್‌ಗಳು, ಹೊಸ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಲ್ಪಟ್ಟು, ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಅಸಿಂಕ್ರೊನಸ್ ಆಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಪ್ರಬಲವಾದ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ. ಆದಾಗ್ಯೂ, ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಎಚ್ಚರಿಕೆಯಿಂದ ನಿರ್ವಹಿಸದಿದ್ದರೆ ತ್ವರಿತವಾಗಿ ಮೆಮೊರಿ ಸಮಸ್ಯೆಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. ಈ ಲೇಖನವು ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳ ಮೆಮೊರಿ ದಕ್ಷತೆಯ ಅಂಶಗಳನ್ನು ಮತ್ತು ಅತ್ಯುತ್ತಮ ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಸ್ಕೇಲೆಬಿಲಿಟಿಗಾಗಿ ನಿಮ್ಮ ಅಸಿಂಕ್ರೊನಸ್ ಸ್ಟ್ರೀಮ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಹೇಗೆ ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವುದು ಎಂಬುದರ ಕುರಿತು ಪರಿಶೀಲಿಸುತ್ತದೆ.

ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳು ಮತ್ತು ಜನರೇಟರ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ನಾವು ಮೆಮೊರಿ ದಕ್ಷತೆಯ ಬಗ್ಗೆ ಆಳವಾಗಿ ಪರಿಶೀಲಿಸುವ ಮೊದಲು, ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳು ಮತ್ತು ಜನರೇಟರ್‌ಗಳನ್ನು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಪುನರಾವಲೋಕಿಸೋಣ.

ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳು

ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಎನ್ನುವುದು next() ವಿಧಾನವನ್ನು ಒದಗಿಸುವ ಒಂದು ವಸ್ತುವಾಗಿದ್ದು, ಇದು ಪ್ರಾಮಿಸ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಮತ್ತು {value, done} ವಸ್ತುವಿಗೆ ಪರಿಹಾರ ನೀಡುತ್ತದೆ. ಇದು ನಿಮಗೆ ಅಸಿಂಕ್ರೊನಸ್ ಆಗಿ ಡೇಟಾ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಪುನರಾವರ್ತಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಇಲ್ಲಿದೆ ಒಂದು ಸರಳ ಉದಾಹರಣೆ:

            async function* generateNumbers() {
  for (let i = 0; i < 10; i++) {
    await new Promise(resolve => setTimeout(resolve, 100)); // Simulate async operation
    yield i;
  }
}

const asyncIterator = generateNumbers();

async function consumeIterator() {
  while (true) {
    const { value, done } = await asyncIterator.next();
    if (done) break;
    console.log(value);
  }
}

consumeIterator();
            

              
                Copy
              
            
          

ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳು

ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳು ತಮ್ಮ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ವಿರಾಮಗೊಳಿಸಿ ಮತ್ತು ಪುನರಾರಂಭಿಸಬಲ್ಲ ಕಾರ್ಯಗಳಾಗಿವೆ, ಅಸಿಂಕ್ರೊನಸ್ ಆಗಿ ಮೌಲ್ಯಗಳನ್ನು ನೀಡುತ್ತವೆ. ಅವುಗಳನ್ನು async function* ಸಿಂಟ್ಯಾಕ್ಸ್ ಬಳಸಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ. ಮೇಲಿನ ಉದಾಹರಣೆಯು ಸ್ವಲ್ಪ ವಿಳಂಬದೊಂದಿಗೆ ಸಂಖ್ಯೆಗಳನ್ನು ನೀಡುವ ಮೂಲಭೂತ ಅಸಿಂಕ್ ಜನರೇಟರ್ ಅನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳ ಪರಿಚಯ

ಇಟರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳು AsyncIterator.prototype (ಮತ್ತು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಇಟರೇಟರ್ ಪ್ರೊಟೊಟೈಪ್) ಗೆ ಸೇರಿಸಲಾದ ವಿಧಾನಗಳ ಒಂದು ಗುಂಪಾಗಿದ್ದು, ಇದು ಸ್ಟ್ರೀಮ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ. ಈ ಹೆಲ್ಪರ್‌ಗಳು ನಿಮಗೆ map, filter, reduce, ಮತ್ತು ಇತರ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ದೀರ್ಘವಾದ ಲೂಪ್‌ಗಳನ್ನು ಬರೆಯುವ ಅಗತ್ಯವಿಲ್ಲದೆ ನೇರವಾಗಿ ಇಟರೇಟರ್ ಮೇಲೆ ನಿರ್ವಹಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತವೆ. ಅವುಗಳನ್ನು ಸಂಯೋಜಿತ ಮತ್ತು ದಕ್ಷವಾಗಿರುವಂತೆ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.

ಉದಾಹರಣೆಗೆ, ನಮ್ಮ generateNumbers ಜನರೇಟರ್‌ನಿಂದ ಉತ್ಪತ್ತಿಯಾದ ಸಂಖ್ಯೆಗಳನ್ನು ದ್ವಿಗುಣಗೊಳಿಸಲು, ನಾವು map ಹೆಲ್ಪರ್ ಅನ್ನು ಬಳಸಬಹುದು:

            async function* generateNumbers() {
  for (let i = 0; i < 10; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

async function consumeIterator() {
  const doubledNumbers = generateNumbers().map(x => x * 2);
  for await (const num of doubledNumbers) {
    console.log(num);
  }
}

consumeIterator();
            

              
                Copy
              
            
          

ಮೆಮೊರಿ ದಕ್ಷತೆಯ ಪರಿಗಣನೆಗಳು

ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳು ಅಸಿಂಕ್ರೊನಸ್ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅನುಕೂಲಕರ ಮಾರ್ಗವನ್ನು ಒದಗಿಸಿದರೂ, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಮೆಮೊರಿ ಬಳಕೆಯ ಮೇಲೆ ಅವುಗಳ ಪ್ರಭಾವವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ. ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸದಿದ್ದರೆ ಮಧ್ಯಂತರ ಫಲಿತಾಂಶಗಳು ಮೆಮೊರಿಯಲ್ಲಿ ಬಫರ್ ಆಗಬಹುದು ಎಂಬುದು ಪ್ರಮುಖ ಕಾಳಜಿಯಾಗಿದೆ. ಸಾಮಾನ್ಯ ಅಪಾಯಗಳು ಮತ್ತು ಆಪ್ಟಿಮೈಸೇಶನ್ ತಂತ್ರಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ.

ಬಫರಿಂಗ್ ಮತ್ತು ಮೆಮೊರಿ ಬ್ಲೋಟ್

ಅನೇಕ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳು, ತಮ್ಮ ಸ್ವಭಾವದಿಂದ, ಡೇಟಾವನ್ನು ಬಫರ್ ಮಾಡಬಹುದು. ಉದಾಹರಣೆಗೆ, ನೀವು ದೊಡ್ಡ ಸ್ಟ್ರೀಮ್‌ನಲ್ಲಿ toArray ಬಳಸಿದರೆ, ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಅರೇ ಆಗಿ ಹಿಂದಿರುಗಿಸುವ ಮೊದಲು ಮೆಮೊರಿಯಲ್ಲಿ ಲೋಡ್ ಮಾಡಲಾಗುತ್ತದೆ. ಅಂತೆಯೇ, ಸರಿಯಾದ ಪರಿಗಣನೆಯಿಲ್ಲದೆ ಅನೇಕ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಸರಣಿ ಮಾಡುವುದರಿಂದ ಗಮನಾರ್ಹ ಮೆಮೊರಿಯನ್ನು ಬಳಸುವ ಮಧ್ಯಂತರ ಬಫರ್‌ಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.

ಕೆಳಗಿನ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸಿ:

            async function* generateLargeDataset() {
  for (let i = 0; i < 1000000; i++) {
    yield i;
  }
}

async function processData() {
  const result = await generateLargeDataset()
    .filter(x => x % 2 === 0)
    .map(x => x * 2)
    .toArray(); // All filtered and mapped values are buffered in memory
  console.log(`Processed ${result.length} elements`);
}

processData();
            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, toArray() ವಿಧಾನವು processData ಫಂಕ್ಷನ್ ಮುಂದುವರೆಯುವ ಮೊದಲು ಸಂಪೂರ್ಣ ಫಿಲ್ಟರ್ ಮಾಡಿದ ಮತ್ತು ಮ್ಯಾಪ್ ಮಾಡಿದ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಮೆಮೊರಿಯಲ್ಲಿ ಲೋಡ್ ಮಾಡಲು ಒತ್ತಾಯಿಸುತ್ತದೆ. ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳಿಗೆ, ಇದು ಮೆಮೊರಿ-ಮೀರಿದ ದೋಷಗಳಿಗೆ ಅಥವಾ ಗಮನಾರ್ಹ ಕಾರ್ಯಕ್ಷಮತೆಯ ಅವನತಿಗೆ ಕಾರಣವಾಗಬಹುದು.

ಸ್ಟ್ರೀಮಿಂಗ್ ಮತ್ತು ರೂಪಾಂತರದ ಶಕ್ತಿ

ಮೆಮೊರಿ ಸಮಸ್ಯೆಗಳನ್ನು ತಗ್ಗಿಸಲು, ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳ ಸ್ಟ್ರೀಮಿಂಗ್ ಸ್ವರೂಪವನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವುದು ಮತ್ತು ಹೆಚ್ಚುವರಿಯಾಗಿ ರೂಪಾಂತರಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಅತ್ಯಗತ್ಯ. ಮಧ್ಯಂತರ ಫಲಿತಾಂಶಗಳನ್ನು ಬಫರ್ ಮಾಡುವ ಬದಲು, ಪ್ರತಿ ಅಂಶವು ಲಭ್ಯವಾದಂತೆ ಅದನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ. ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ರಚಿಸುವ ಮೂಲಕ ಮತ್ತು ಪೂರ್ಣ ಬಫರಿಂಗ್ ಅಗತ್ಯವಿರುವ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ತಪ್ಪಿಸುವ ಮೂಲಕ ಇದನ್ನು ಸಾಧಿಸಬಹುದು.

ಮೆಮೊರಿ ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಾಗಿ ತಂತ್ರಗಳು

ನಿಮ್ಮ ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ ಕೋಡ್‌ನ ಮೆಮೊರಿ ದಕ್ಷತೆಯನ್ನು ಸುಧಾರಿಸಲು ಹಲವಾರು ತಂತ್ರಗಳು ಇಲ್ಲಿವೆ:

1. ಅನಗತ್ಯ toArray ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ತಪ್ಪಿಸಿ

toArray ವಿಧಾನವು ಸಾಮಾನ್ಯವಾಗಿ ಮೆಮೊರಿ ಬ್ಲೋಟ್‌ನ ಪ್ರಮುಖ ಕಾರಣವಾಗಿದೆ. ಸಂಪೂರ್ಣ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಅರೇ ಆಗಿ ಪರಿವರ್ತಿಸುವ ಬದಲು, ಇಟರೇಟರ್ ಮೂಲಕ ಡೇಟಾ ಹರಿಯುವಾಗ ಅದನ್ನು ಪುನರಾವರ್ತಿತವಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ. ನೀವು ಫಲಿತಾಂಶಗಳನ್ನು ಒಟ್ಟುಗೂಡಿಸಬೇಕಾದರೆ, reduce ಅಥವಾ ಕಸ್ಟಮ್ ಅಕ್ಯುಮ್ಯುಲೇಟರ್ ಮಾದರಿಯನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.

ಉದಾಹರಣೆಗೆ, ಇದರ ಬದಲು:

            const result = await generateLargeDataset().toArray();
// ... process the 'result' array
            

              
                Copy
              
            
          

ಬಳಸಿ:

            let sum = 0;
for await (const item of generateLargeDataset()) {
  sum += item;
}
console.log(`Sum: ${sum}`);
            

              
                Copy
              
            
          

2. ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಗಾಗಿ reduce ಅನ್ನು ಬಳಸಿ

reduce ಹೆಲ್ಪರ್ ನಿಮಗೆ ಸಂಪೂರ್ಣ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಬಫರ್ ಮಾಡದೆ ಸ್ಟ್ರೀಮ್‌ನಿಂದ ಮೌಲ್ಯಗಳನ್ನು ಒಂದೇ ಫಲಿತಾಂಶಕ್ಕೆ ಸಂಗ್ರಹಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಇದು ಅಕ್ಯುಮ್ಯುಲೇಟರ್ ಫಂಕ್ಷನ್ ಮತ್ತು ಆರಂಭಿಕ ಮೌಲ್ಯವನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಾಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

            async function processData() {
  const sum = await generateLargeDataset().reduce((acc, x) => acc + x, 0);
  console.log(`Sum: ${sum}`);
}

processData();
            

              
                Copy
              
            
          

3. ಕಸ್ಟಮ್ ಅಕ್ಯುಮ್ಯುಲೇಟರ್‌ಗಳನ್ನು ಅಳವಡಿಸಿ

ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಒಟ್ಟುಗೂಡಿಸುವ ಸನ್ನಿವೇಶಗಳಿಗಾಗಿ, ನೀವು ಮೆಮೊರಿಯನ್ನು ಸಮರ್ಥವಾಗಿ ನಿರ್ವಹಿಸುವ ಕಸ್ಟಮ್ ಅಕ್ಯುಮ್ಯುಲೇಟರ್‌ಗಳನ್ನು ಅಳವಡಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಸಂಪೂರ್ಣ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡದೆ ಫಲಿತಾಂಶಗಳನ್ನು ಅಂದಾಜು ಮಾಡಲು ನೀವು ಸ್ಥಿರ-ಗಾತ್ರದ ಬಫರ್ ಅಥವಾ ಸ್ಟ್ರೀಮಿಂಗ್ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಬಳಸಬಹುದು.

4. ಮಧ್ಯಂತರ ಕಾರ್ಯಾಚರಣೆಗಳ ವ್ಯಾಪ್ತಿಯನ್ನು ಸೀಮಿತಗೊಳಿಸಿ

ಅನೇಕ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಸರಣಿ ಮಾಡುವಾಗ, ಪ್ರತಿ ಹಂತದ ಮೂಲಕ ಹಾದುಹೋಗುವ ಡೇಟಾದ ಪ್ರಮಾಣವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿ. ಮ್ಯಾಪಿಂಗ್ ಅಥವಾ ರೂಪಾಂತರದಂತಹ ಹೆಚ್ಚು ದುಬಾರಿ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಮೊದಲು ಡೇಟಾಸೆಟ್‌ನ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಸರಣಿಯ ಆರಂಭದಲ್ಲಿ ಫಿಲ್ಟರ್‌ಗಳನ್ನು ಅನ್ವಯಿಸಿ.

            const result = generateLargeDataset()
  .filter(x => x > 1000) // Filter early
  .map(x => x * 2)
  .filter(x => x < 10000) // Filter again
  .take(100); // Take only the first 100 elements

// ... consume the result
            

              
                Copy
              
            
          

5. ಸ್ಟ್ರೀಮ್ ಮಿತಿಗೊಳಿಸಲು take ಮತ್ತು drop ಬಳಸಿ

take ಮತ್ತು drop ಹೆಲ್ಪರ್‌ಗಳು ಸ್ಟ್ರೀಮ್‌ನಿಂದ ಸಂಸ್ಕರಿಸಿದ ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಮಿತಿಗೊಳಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. take(n) ಕೇವಲ ಮೊದಲ n ಅಂಶಗಳನ್ನು ನೀಡುವ ಹೊಸ ಇಟರೇಟರ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಆದರೆ drop(n) ಮೊದಲ n ಅಂಶಗಳನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ.

            const firstTen = generateLargeDataset().take(10);
const afterFirstHundred = generateLargeDataset().drop(100);
            

              
                Copy
              
            
          

6. ಇಟರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳನ್ನು ನೇಟಿವ್ ಸ್ಟ್ರೀಮ್ಸ್ API ಯೊಂದಿಗೆ ಸಂಯೋಜಿಸಿ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಸ್ಟ್ರೀಮ್ಸ್ API (ReadableStream, WritableStream, TransformStream) ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ದೃಢವಾದ ಮತ್ತು ಸಮರ್ಥವಾದ ಯಾಂತ್ರಿಕತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಶಕ್ತಿಯುತ ಮತ್ತು ಮೆಮೊರಿ-ದಕ್ಷ ಡೇಟಾ ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ರಚಿಸಲು ನೀವು ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳನ್ನು ಸ್ಟ್ರೀಮ್ಸ್ API ಯೊಂದಿಗೆ ಸಂಯೋಜಿಸಬಹುದು.

ಅಸಿಂಕ್ ಜನರೇಟರ್‌ನೊಂದಿಗೆ ReadableStream ಬಳಸುವ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

            async function* generateData() {
  for (let i = 0; i < 1000; i++) {
    yield new TextEncoder().encode(`Data ${i}\n`);
  }
}

const readableStream = new ReadableStream({
  async start(controller) {
    for await (const chunk of generateData()) {
      controller.enqueue(chunk);
    }
    controller.close();
  }
});

const transformStream = new TransformStream({
  transform(chunk, controller) {
    const text = new TextDecoder().decode(chunk);
    const transformedText = text.toUpperCase();
    controller.enqueue(new TextEncoder().encode(transformedText));
  }
});

const writableStream = new WritableStream({
  write(chunk) {
    const text = new TextDecoder().decode(chunk);
    console.log(text);
  }
});

readableStream
  .pipeThrough(transformStream)
  .pipeTo(writableStream);

            

              
                Copy
              
            
          

7. ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್ ಅನ್ನು ಅಳವಡಿಸಿ

ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಎನ್ನುವುದು ಗ್ರಾಹಕರಿಗೆ ಉತ್ಪಾದಕರಿಗೆ ಅವರು ಡೇಟಾವನ್ನು ಉತ್ಪಾದಿಸುತ್ತಿರುವಷ್ಟು ವೇಗವಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ಸಂಕೇತಿಸಲು ಅನುಮತಿಸುವ ಒಂದು ಯಾಂತ್ರಿಕತೆಯಾಗಿದೆ. ಇದು ಗ್ರಾಹಕರು ಮುಳುಗಿಹೋಗುವುದನ್ನು ಮತ್ತು ಮೆಮೊರಿ ಖಾಲಿಯಾಗುವುದನ್ನು ತಡೆಯುತ್ತದೆ. ಸ್ಟ್ರೀಮ್ಸ್ API ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್‌ಗೆ ಅಂತರ್ನಿರ್ಮಿತ ಬೆಂಬಲವನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಸ್ಟ್ರೀಮ್ಸ್ API ಜೊತೆಯಲ್ಲಿ ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳನ್ನು ಬಳಸುವಾಗ, ಮೆಮೊರಿ ಸಮಸ್ಯೆಗಳನ್ನು ತಡೆಯಲು ನೀವು ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಅನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುತ್ತೀರೆಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಗ್ರಾಹಕರು ಕಾರ್ಯನಿರತರಾಗಿದ್ದಾಗ ಉತ್ಪಾದಕರನ್ನು (ಉದಾ., ಅಸಿಂಕ್ ಜನರೇಟರ್) ವಿರಾಮಗೊಳಿಸುವುದು ಮತ್ತು ಗ್ರಾಹಕರು ಹೆಚ್ಚಿನ ಡೇಟಾಗೆ ಸಿದ್ಧರಾದಾಗ ಅದನ್ನು ಪುನರಾರಂಭಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.

8. flatMap ಅನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಬಳಸಿ

flatMap ಹೆಲ್ಪರ್ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ರೂಪಾಂತರಿಸಲು ಮತ್ತು ಫ್ಲಾಟ್ ಮಾಡಲು ಉಪಯುಕ್ತವಾಗಬಹುದು, ಆದರೆ ಎಚ್ಚರಿಕೆಯಿಂದ ಬಳಸದಿದ್ದರೆ ಅದು ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಹೆಚ್ಚಿಸಲು ಕಾರಣವಾಗಬಹುದು. flatMap ಗೆ ರವಾನಿಸಲಾದ ಫಂಕ್ಷನ್ ಮೆಮೊರಿ-ದಕ್ಷವಾದ ಇಟರೇಟರ್‌ಗಳನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

9. ಪರ್ಯಾಯ ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್ ಲೈಬ್ರರಿಗಳನ್ನು ಪರಿಗಣಿಸಿ

ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳು ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಅನುಕೂಲಕರವಾದ ಮಾರ್ಗವನ್ನು ಒದಗಿಸಿದರೂ, ವಿಶೇಷವಾಗಿ ಸಂಕೀರ್ಣ ಡೇಟಾ ಪೈಪ್‌ಲೈನ್‌ಗಳಿಗಾಗಿ ಅಥವಾ ಕಾರ್ಯಕ್ಷಮತೆಯು ನಿರ್ಣಾಯಕವಾದಾಗ Highland.js, RxJS, ಅಥವಾ Bacon.js ನಂತಹ ಇತರ ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್ ಲೈಬ್ರರಿಗಳನ್ನು ಅನ್ವೇಷಿಸುವುದನ್ನು ಪರಿಗಣಿಸಿ. ಈ ಲೈಬ್ರರಿಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಹೆಚ್ಚು ಅತ್ಯಾಧುನಿಕ ಮೆಮೊರಿ ನಿರ್ವಹಣಾ ತಂತ್ರಗಳು ಮತ್ತು ಆಪ್ಟಿಮೈಸೇಶನ್ ತಂತ್ರಗಳನ್ನು ನೀಡುತ್ತವೆ.

10. ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಪ್ರೊಫೈಲ್ ಮಾಡಿ ಮತ್ತು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಿ

ಮೆಮೊರಿ ಸಮಸ್ಯೆಗಳನ್ನು ಗುರುತಿಸಲು ಮತ್ತು ಪರಿಹರಿಸಲು ಅತ್ಯಂತ ಪರಿಣಾಮಕಾರಿ ಮಾರ್ಗವೆಂದರೆ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಪ್ರೊಫೈಲ್ ಮಾಡುವುದು ಮತ್ತು ರನ್‌ಟೈಮ್ ಸಮಯದಲ್ಲಿ ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವುದು. ಮೆಮೊರಿ ಸೋರಿಕೆಗಳು, ಅತಿಯಾದ ಹಂಚಿಕೆಗಳು ಮತ್ತು ಇತರ ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಡಚಣೆಗಳನ್ನು ಗುರುತಿಸಲು Node.js ಇನ್ಸ್‌ಪೆಕ್ಟರ್, ಕ್ರೋಮ್ ಡೆವ್‌ಟೂಲ್ಸ್ ಅಥವಾ ವಿಶೇಷ ಮೆಮೊರಿ ಪ್ರೊಫೈಲಿಂಗ್ ಲೈಬ್ರರಿಗಳಂತಹ ಸಾಧನಗಳನ್ನು ಬಳಸಿ. ನಿಯಮಿತ ಪ್ರೊಫೈಲಿಂಗ್ ಮತ್ತು ಮೇಲ್ವಿಚಾರಣೆ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಉತ್ತಮಗೊಳಿಸಲು ಮತ್ತು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ವಿಕಸನಗೊಂಡಂತೆ ಅದು ಮೆಮೊರಿ-ದಕ್ಷವಾಗಿ ಉಳಿಯುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ನೈಜ-ಪ್ರಪಂಚದ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಕೆಲವು ನೈಜ-ಪ್ರಪಂಚದ ಸನ್ನಿವೇಶಗಳನ್ನು ಮತ್ತು ಈ ಆಪ್ಟಿಮೈಸೇಶನ್ ತಂತ್ರಗಳನ್ನು ಹೇಗೆ ಅನ್ವಯಿಸಬೇಕು ಎಂಬುದನ್ನು ಪರಿಗಣಿಸೋಣ:

ಸನ್ನಿವೇಶ 1: ಲಾಗ್ ಫೈಲ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು

ನೀವು ಲಕ್ಷಾಂತರ ಸಾಲುಗಳನ್ನು ಹೊಂದಿರುವ ದೊಡ್ಡ ಲಾಗ್ ಫೈಲ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬೇಕಾಗಿದೆ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ನೀವು ದೋಷ ಸಂದೇಶಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು, ಸಂಬಂಧಿತ ಮಾಹಿತಿಯನ್ನು ಹೊರತೆಗೆಯಲು ಮತ್ತು ಫಲಿತಾಂಶಗಳನ್ನು ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲು ಬಯಸುತ್ತೀರಿ. ಸಂಪೂರ್ಣ ಲಾಗ್ ಫೈಲ್ ಅನ್ನು ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡುವ ಬದಲು, ಫೈಲ್ ಅನ್ನು ಸಾಲು-ಸಾಲು ಓದಲು ನೀವು ReadableStream ಅನ್ನು ಮತ್ತು ಪ್ರತಿ ಸಾಲನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಅಸಿಂಕ್ ಜನರೇಟರ್ ಅನ್ನು ಬಳಸಬಹುದು.

            const fs = require('fs');
const readline = require('readline');

async function* processLogFile(filePath) {
  const fileStream = fs.createReadStream(filePath);

  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });

  for await (const line of rl) {
    if (line.includes('ERROR')) {
      const data = extractDataFromLogLine(line);
      yield data;
    }
  }
}

async function storeDataInDatabase(data) {
  // ... database insertion logic
  await new Promise(resolve => setTimeout(resolve, 10)); // Simulate async database operation
}

async function main() {
  for await (const data of processLogFile('large_log_file.txt')) {
    await storeDataInDatabase(data);
  }
}

main();
            

              
                Copy
              
            
          

ಈ ವಿಧಾನವು ಲಾಗ್ ಫೈಲ್ ಅನ್ನು ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಸಾಲಿನಂತೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ, ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.

ಸನ್ನಿವೇಶ 2: API ಯಿಂದ ನೈಜ-ಸಮಯದ ಡೇಟಾ ಪ್ರಕ್ರಿಯೆ

ನೀವು ಅಸಿಂಕ್ರೊನಸ್ ಸ್ಟ್ರೀಮ್ ರೂಪದಲ್ಲಿ API ಯಿಂದ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸುವ ನೈಜ-ಸಮಯದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಭಾವಿಸೋಣ. ನೀವು ಡೇಟಾವನ್ನು ರೂಪಾಂತರಿಸಬೇಕು, ಅಪ್ರಸ್ತುತ ಮಾಹಿತಿಯನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಬೇಕು ಮತ್ತು ಬಳಕೆದಾರರಿಗೆ ಫಲಿತಾಂಶಗಳನ್ನು ಪ್ರದರ್ಶಿಸಬೇಕು. ಡೇಟಾ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಸಮರ್ಥವಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ನೀವು fetch API ಜೊತೆಯಲ್ಲಿ ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.

            async function* fetchDataStream(url) {
  const response = await fetch(url);
  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      const text = decoder.decode(value);
      const lines = text.split('\n');
      for (const line of lines) {
        if (line) {
          yield JSON.parse(line);
        }
      }
    }
  } finally {
    reader.releaseLock();
  }
}

async function displayData() {
  for await (const item of fetchDataStream('https://api.example.com/data')) {
    if (item.value > 100) {
      console.log(item);
      // Update UI with data
    }
  }
}

displayData();
            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯು ಡೇಟಾವನ್ನು ಸ್ಟ್ರೀಮ್ ಆಗಿ ಪಡೆದುಕೊಳ್ಳುವುದು ಮತ್ತು ಅದನ್ನು ಹೆಚ್ಚುವರಿಯಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು ಹೇಗೆ ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ, ಸಂಪೂರ್ಣ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡುವ ಅಗತ್ಯವನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.

ತೀರ್ಮಾನ

ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಅಸಿಂಕ್ರೊನಸ್ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಶಕ್ತಿಯುತ ಮತ್ತು ಅನುಕೂಲಕರ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ. ಆದಾಗ್ಯೂ, ಅವುಗಳ ಮೆಮೊರಿ ಪರಿಣಾಮಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮತ್ತು ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಮೆಮೊರಿ ಬ್ಲೋಟ್ ಅನ್ನು ತಡೆಯಲು ಆಪ್ಟಿಮೈಸೇಶನ್ ತಂತ್ರಗಳನ್ನು ಅನ್ವಯಿಸುವುದು ಬಹಳ ಮುಖ್ಯ. ಅನಗತ್ಯ ಬಫರಿಂಗ್ ಅನ್ನು ತಪ್ಪಿಸುವುದು, reduce ಅನ್ನು ಬಳಸುವುದು, ಮಧ್ಯಂತರ ಕಾರ್ಯಾಚರಣೆಗಳ ವ್ಯಾಪ್ತಿಯನ್ನು ಸೀಮಿತಗೊಳಿಸುವುದು, ಮತ್ತು ಸ್ಟ್ರೀಮ್ಸ್ API ಯೊಂದಿಗೆ ಸಂಯೋಜಿಸುವುದರ ಮೂಲಕ, ನೀವು ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುವ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಗರಿಷ್ಠಗೊಳಿಸುವ ದಕ್ಷ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಅಸಿಂಕ್ರೊನಸ್ ಡೇಟಾ ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು. ಯಾವುದೇ ಸಂಭಾವ್ಯ ಸಮಸ್ಯೆಗಳನ್ನು ಗುರುತಿಸಲು ಮತ್ತು ಪರಿಹರಿಸಲು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ನಿಯಮಿತವಾಗಿ ಪ್ರೊಫೈಲ್ ಮಾಡಲು ಮತ್ತು ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು ಮರೆಯದಿರಿ. ಈ ತಂತ್ರಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳ ಸಂಪೂರ್ಣ ಸಾಮರ್ಥ್ಯವನ್ನು ಅನ್‌ಲಾಕ್ ಮಾಡಬಹುದು ಮತ್ತು ಅತ್ಯಂತ ಬೇಡಿಕೆಯ ಡೇಟಾ ಪ್ರೊಸೆಸಿಂಗ್ ಕಾರ್ಯಗಳನ್ನು ಸಹ ನಿಭಾಯಿಸಬಲ್ಲ ದೃಢವಾದ ಮತ್ತು ಸ್ಪಂದಿಸುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು.

ಅಂತಿಮವಾಗಿ, ಮೆಮೊರಿ ದಕ್ಷತೆಗಾಗಿ ಆಪ್ಟಿಮೈಜ್ ಮಾಡಲು ಎಚ್ಚರಿಕೆಯ ಕೋಡ್ ವಿನ್ಯಾಸ, API ಗಳ ಸೂಕ್ತ ಬಳಕೆ, ಮತ್ತು ನಿರಂತರ ಮೇಲ್ವಿಚಾರಣೆ ಮತ್ತು ಪ್ರೊಫೈಲಿಂಗ್‌ನ ಸಂಯೋಜನೆಯ ಅಗತ್ಯವಿದೆ. ಅಸಿಂಕ್ರೊನಸ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಸರಿಯಾಗಿ ಮಾಡಿದಾಗ, ನಿಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಸ್ಕೇಲೆಬಿಲಿಟಿಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸಬಹುದು.